PTX3 Polymorphisms and Invasive Mold Infections After Solid Organ Transplant

Donor PTX3 polymorphisms were shown to influence the risk of invasive aspergillosis among hematopoietic stem cell transplant recipients. Here, we show that PTX3 polymorphisms are independent risk factors for invasive mold infections among 1101 solid organ transplant recipients, thereby strengthening their role in mold infection pathogenesis and patients' risk stratificatio

Twenty years of coordination technologies: State-of-the-art and perspectives

Since complexity of inter- and intra-systems interactions is steadily increasing in modern application scenarios (e.g., the IoT), coordination technologies are required to take a crucial step towards maturity. In this paper we look back at the history of the COORDINATION conference in order to shed light on the current status of the coordination technologies there proposed throughout the years, in an attempt to understand success stories, limitations, and possibly reveal the gap between actual technologies, theoretical models, and novel application needs

Forms, Agents and Channels: Defining Composition Abstraction with Style

Object-oriented technology and design is not the final answer to the recurrent problem of making systems, on one hand, more open and flexible and, on the other hand, more robust, safe, and fast. While object-oriented languages have a lot of success in implementing components, they have rather limited support for expressing composition abstractions. As such, the component-based software principle is only partially supported by the object-oriented approach. Component-based software development breaks down an application into stable parts, i.e., the components, and high-level abstractions for composing the components. Flexibility is provided by the possibility to recompose. How can we design a composition language to support this metaphor? What mechanisms are needed to encapsulate components, to make their contextual assumptions explicit, and to define composition abstractions in a compact way? We argue that we should seek the minimal kernel of mechanisms that allows us to define composition abstractions, instead of adding additional language constructs to the object-oriented paradigm. This is necessary in order to reason about these abstractions and derive properties of the composed application. In this thesis we propose Forms, Agents and Channels as this minimal set of abstractions. Forms are extensible records unified with services. They are primitive objects, act as explicit namespaces, and encapsulate arguments to invoke services. Agents are autonomous entities that exchange forms along channels. We show that this simple model is expressive enough to define high-level composition abstractions while being small enough to be mathematically tractable. We present the formal model of forms, agents and channels in terms of a composition calculus. We encode the composition calculus into the asynchronous pi-calculus and show the soundness of this encoding. We define the composition language Piccola on top of the composition calculus by adding some syntactic sugar and by defining a bridge to access external components. The usefulness of Piccola is demonstrated by defining composition abstractions and reasoning about them at the level of the language. We present several kinds of composition abstractions: wrappers to adapt components, connectors to implement composition styles, and coordination abstractions that cross-cut the functional decomposition of a system. We also demonstrate how to reason about composition and how to use glue code to detect and fix compositional mismatches

Language Support for Feature Mixing

Object oriented languages cannot express certain composition abstractions due to restricted abstraction power. A number of approaches, like SOP or AOP overcome this restriction, thus giving the programmer more possibilities to get a higher degree of separation of concern. We propose forms, extensible mappings from labels to values, as vehicle to implement and reason about composition abstractions. Forms unify a variety of concepts such as interfaces, environments, and contexts. We are prototyping a composition language where forms are the only and ubiquitous first class value. Using forms, it is possible compose software artifacts focusing on a single concern and thus achieve a high degree of separation of concern. We believe that using forms it also possible to compare and reason about the di#erent composition mechanisms proposed. 1 Introduction It is well accepted that software should be developed as manageable pieces, ideally each implementing a single concern. These piec..

Partial Evaluation of Inter-Language Wrappers

Wrapping external components by scripts can be a performance bottleneck if inter-language bridging is frequent. Piccola is a pure composition language that wraps components according to a specific composition style. This wrapping must be efficient, since even arithmetic operations are done by external components. In this paper we present how to use partial evaluation to overcome much of the overhead associated with the wrapping. It turns out that Piccola scripts can be highly optimized since form expression exhibit the right kind of information to separate side effects from services and resolve internal dependencies

Separating concerns with first-class namespaces

www.iam.unibe.ch/∼scg. As applications evolve, it becomes harder and harder to separate independent concerns. Small changes to a software system increasingly affect different parts of the source code. AOP and related approaches offer various ways to separate concerns into concrete software artifacts, but what is the essence of this process? We claim that first-class namespaces — which we refer to as forms — offer a suitable foundation for separating concerns by offering simple yet expressive mechanisms for defining composable abstractions. We demonstrate how forms help a programmer to separate concerns by means of practical examples in Piccola, an experimental composition language.

Separation of Concerns through Unification of Concepts

Separation of concerns is a principle we apply to reduce complexity, This principle is especially important when it is used to separate stable from flexible parts of software systems to reduce the complexity of software evolution, We encapsulate the stable parts as components and the flexible parts as scripts, But there is a large range of requirements and consequent techniques available to achieve this separation, We propose a simple, unifying framework of forms, agents, and channels for modelling components and scripts, We have also developed an experimental composition language, called Piccola, based on this framework, that supports the specification of applications as flexible compositions of stable components, 1

Explicit Namespaces

. A namespace is a mapping from labels to values. Most programming languages support different forms of namespaces, such as records, dictionaries, objects, environments, packages and even keyword-based parameters. Typically only a few of these notions are first-class, leading to arbitrary restrictions and limited abstraction power in the host language. Piccola is a small language that unifies various notions of namespaces as first-class forms, or extensible, immutable records. By making namespaces explicit, Piccola is easily able to express various abstractions that would normally require more heavyweight techniques, such as language extensions or meta-programming. 1 Introduction Virtually all programming languages support various notions of namespaces, or sets of bindings of labels to values. These include: . Interface. Objects have a set of named methods. . Scopes. Identifiers are bound in the enclosing static or dynamic scope. . Package. A package provides a set of name..